home *** CD-ROM | disk | FTP | other *** search
/ Gamers Delight 2 / Gamers Delight 2.iso / Aminet / game / gag / walkingman.lha / WalkingMan / Sources / Bewegungsgenerator / Bewegung.c < prev    next >
C/C++ Source or Header  |  1992-08-04  |  10KB  |  413 lines
  1. /* JPK13.04.92-26.04.92+22.05.92 */
  2.  
  3. #define BEWEGUNG_PRIVAT
  4. #include "Bewegungsgenerator/Bewegung.h"
  5. #undef BEWEGUNG_PRIVAT
  6.  
  7.  
  8.     /***** private Daten *****/
  9.  
  10. struct Mannliste Mannliste;
  11. long Altprioritaet;
  12. struct Task *MyTask;
  13. UBYTE eigene_Sprites;
  14.  
  15.  
  16.     /***** Funktionen *****/
  17.  
  18. void Bewegung_Init(mannenzahl)
  19. WORD mannenzahl;
  20.     {
  21.     Liste_Init();
  22.     Zufall_Init();
  23.     Liste_C_Neu(&Mannliste);
  24.     Analyse_Init(&Mannliste);
  25.     Disp_Init();
  26.     while(mannenzahl>0)
  27.         {
  28.         mannenzahl--;
  29.         if(!Bewegung_Neu())
  30.             break;
  31.         }
  32.     if(MyTask = FindTask(0L))
  33.         Altprioritaet = SetTaskPri(MyTask, 5L);
  34.     }
  35.  
  36. void Mann_entfernen(mann)
  37. struct Manneintrag *mann;
  38.     {
  39.     Analyse_Alt(mann);
  40.     Disp_Alt(mann);
  41.     FreeMem(mann, (long)sizeof(*mann));
  42.     if(Liste_C_Leer(&Mannliste) && Flags.finale)
  43.         Flags.quit = 1;
  44.     }
  45.  
  46. void Bewegung_Clear()
  47.     {
  48.     if(MyTask)
  49.         SetTaskPri(MyTask, Altprioritaet);
  50.     Liste_C_Alt(&Mannliste, Mann_entfernen);
  51.     Analyse_Clear();
  52.     Disp_Clear();
  53.     Liste_Clear();
  54.     }
  55.  
  56. char Bewegung_Neu()
  57.     {
  58.     struct Manneintrag *mann = (struct Manneintrag *)
  59.         AllocMem((long)sizeof(struct Manneintrag), MEMF_CLEAR|MEMF_CHIP);
  60.  
  61.     if(mann)
  62.         {
  63.         mann->Bewegungsart = stehen;
  64.         mann->Warten = SEK2_0;
  65.         if(Disp_Neu(mann))
  66.             {
  67.             Analyse_Neu(mann);
  68.             Liste_C_Nachfuegen(&Mannliste, mann, &Mannliste);
  69.             return(1);
  70.             }
  71.         FreeMem(mann, (long)sizeof(*mann));
  72.         }
  73.     Fehler();
  74.     return(0);
  75.     }
  76.  
  77.  
  78. void Bewegung_Alt(anzahl)
  79. UWORD anzahl;
  80.     {
  81.     struct Manneintrag *mann =
  82.         (struct Manneintrag *)Liste_C_Vater(&Mannliste, &Mannliste);
  83.     while(!Liste_C_Stop(&Mannliste, mann) && anzahl>0)
  84.         {
  85.         if(!mann->verschwindet)
  86.             {
  87.             mann->verschwindet = 1;
  88.             mann->Warten = 1;
  89.             anzahl--;
  90.             }
  91.         mann = (struct Manneintrag *)
  92.             Liste_C_Vater(&Mannliste, mann);
  93.         }
  94.     }
  95.  
  96.  
  97. void Bewegung_Halbschritt()
  98.     {
  99.     struct Manneintrag *mann;
  100.  
  101.     mann = (struct Manneintrag *)Liste_C_Sohn(&Mannliste, &Mannliste);
  102.     while(!Liste_C_Stop(&Mannliste, mann))
  103.         {
  104.         if(mann->Bewegungsart!=klettern)
  105.             mann->posX += mann->speedX;
  106.         mann->posY += mann->speedY;
  107.         Disp_Schritt(mann);
  108.         mann = (struct Manneintrag *)Liste_C_Sohn(&Mannliste, mann);
  109.         }
  110.     }
  111.  
  112. void Bewegung_Schritt()
  113.     {
  114.     struct Manneintrag
  115.         *mann = (struct Manneintrag *)Liste_C_Sohn(&Mannliste, &Mannliste),
  116.         *vater;
  117.  
  118.     Analyse_Screens(&Mannliste);
  119.  
  120.     while(!Liste_C_Stop(&Mannliste, mann))
  121.         {
  122.         switch(mann->Bewegungsart)
  123.             {
  124.             case unsichtbar:
  125.                 if(mann->verschwindet)
  126.                     {
  127.                     vater = (struct Manneintrag *)
  128.                         Liste_C_Vater(&Mannliste, mann);
  129.                     Mann_entfernen(Liste_C_Ausfuegen(&Mannliste, mann));
  130.                     mann = vater;
  131.                     }
  132.                 goto nextmann;
  133.             case klettern:
  134.                 mann->Warten--;
  135.                 if(!mann->Warten)
  136.                     {
  137.                     if(Zufall_Muenzwurf() && !mann->verschwindet)
  138.                         mann->Warten = 1+Zufall_C_Wert((long)SEK10_0);
  139.                     else
  140.                         {
  141.                         mann->Bewegungsart = fallen;
  142.                         mann->bild = DISP_FALLEND;
  143.                         }
  144.                     }
  145.  
  146.                 mann->posY += mann->speedY;
  147.  
  148.                 if((mann->speedX>0)?
  149.                     !Analyse_Vert(mann->grund,
  150.                         mann->posX>>KOMMA,mann->posY>>KOMMA, 2L):
  151.                     !Analyse_Vert(mann->grund,
  152.                         (mann->posX>>KOMMA)+MANN_BREITE,
  153.                         mann->posY>>KOMMA, 2L))
  154.                     {
  155.                     if(Analyse_Horiz(mann->grund,
  156.                         mann->posX>>KOMMA,(mann->posY>>KOMMA)-MANN_HAND-1)
  157.                         && !mann->verschwindet)
  158.                         {
  159.                         mann->posY -= MANN_HAND<<KOMMA;
  160.                         mann->speedX = 0;
  161.                         mann->speedY = 0;
  162.                         mann->Bewegungsart = stehen;
  163.                         mann->bild = DISP_STEHEND;
  164.                         mann->Warten = SEK2_0+Zufall_C_Wert((long)SEK2_0);
  165.                         }
  166.                     else
  167.                         {
  168.                         mann->Bewegungsart = fallen;
  169.                         mann->bild = DISP_FALLEND;
  170.                         }
  171.                     }
  172.                 Disp_Schritt(mann);
  173.                 break;
  174.  
  175.             case gehen:
  176.                 mann->posX += mann->speedX;
  177.                 mann->Warten--;
  178.                 if(!mann->Warten)
  179.                     {
  180.                     if(Zufall_Muenzwurf() || mann->verschwindet)
  181.                         mann->Warten = Zufall_C_Wert((long)SEK15_0)+1;
  182.                     else
  183.                         {
  184.                         mann->bild = DISP_STEHEND;
  185.                         mann->Bewegungsart = stehen;
  186.                         mann->Warten = Zufall_C_Wert((long)SEK1_0)+SEK2_0;
  187.                         mann->speedX = 0;
  188.                         }
  189.                     }
  190.  
  191.                     /* Männchen nicht seitlich aus dem Bild gehen lassen */
  192.                 if(!mann->verschwindet)
  193.                     {
  194.                     if((mann->speedX>0)?
  195.                         Analyse_Vert(mann->grund,
  196.                             (mann->posX>>KOMMA)+MANN_BREITE,
  197.                             mann->posY>>KOMMA, 1L):
  198.                         Analyse_Vert(mann->grund,
  199.                             mann->posX>>KOMMA,mann->posY>>KOMMA, 1L))
  200.                         {
  201.                         mann->Bewegungsart = klettern;
  202.                         mann->speedX = -mann->speedX;
  203.                         mann->speedY = -1<<(KOMMA-2);
  204.                         mann->posY &= 0xffff<<KOMMA;
  205.                         mann->bild = (mann->speedX<0)?
  206.                             DISP_LKLETTERND:  DISP_RKLETTERND;
  207.                         mann->Warten = 1+Zufall_C_Wert((long)SEK10_0);
  208.                         Disp_Schritt(mann);
  209.                         break;
  210.                         }
  211.                     }
  212.                 else
  213.                     {
  214.                     if((mann->posX>>KOMMA)<=-MANN_BREITE
  215.                         || (mann->posX>>KOMMA)>=mann->grund->normB)
  216.                         {
  217.                         mann->Bewegungsart = unsichtbar;
  218.                         mann->bild = DISP_UNSICHTBAR;
  219.                         break;
  220.                         }
  221.                     }
  222.  
  223.                 if(Analyse_Horiz(mann->grund,
  224.                     mann->posX>>KOMMA,(mann->posY>>KOMMA)-1)
  225.                     && !mann->verschwindet)
  226.                     {
  227.                     mann->posY -= 1<<KOMMA;
  228.                     }
  229.                 else if(!Analyse_Horiz
  230.                     (mann->grund, mann->posX>>KOMMA,mann->posY>>KOMMA))
  231.                     {
  232.                     mann->Bewegungsart = fallen;
  233.                     mann->bild = DISP_FALLEND;
  234.                     mann->Warten = 0;
  235.                     }
  236.                 Disp_Schritt(mann);
  237.                 break;
  238.  
  239.             case stehen:
  240.                 mann->Warten--;
  241.                 if(!mann->Warten)
  242.                     {
  243.                     if(Zufall_Muenzwurf() && !mann->verschwindet)
  244.                         mann->Warten = 1+Zufall_C_Wert((long)SEK1_0);
  245.                     else
  246.                         {
  247.                         UWORD zufall = Zufall_C_Wert(32L);
  248.  
  249.                         if(zufall<1)            /* hinsetzen */
  250.                             {
  251.                             mann->Bewegungsart = sitzen;
  252.                             mann->bild = DISP_SITZEND;
  253.                             mann->Warten = SEK2_0+Zufall_C_Wert((long)SEK2_0);
  254.                             }
  255.                         else if(zufall<3)        /* abtauchen */
  256.                             {
  257.                             mann->Warten = 2;
  258.                             mann->posY += 3<<KOMMA;
  259.                             }
  260.                         else if(zufall<4)        /* hochspringen */
  261.                             {
  262.                             mann->Bewegungsart = fallen;
  263.                             mann->bild = DISP_FALLEND;
  264.                             mann->speedY = -15;
  265.                             }
  266.                         else                        /* gehen */
  267.                             {
  268.                             mann->Bewegungsart = gehen;
  269.                             mann->Warten = Zufall_C_Wert((long)SEK15_0)+1;
  270.                             if(zufall<18)
  271.                                 {
  272.                                 mann->bild = DISP_RGEHEND;
  273.                                 mann->speedX = 1<<(KOMMA-1);
  274.                                 }
  275.                             else
  276.                                 {
  277.                                 mann->bild = DISP_LGEHEND;
  278.                                 mann->speedX = -1<<(KOMMA-1);
  279.                                 }
  280.                             }
  281.                         Disp_Schritt(mann);
  282.                         break;
  283.                         }
  284.                     }
  285.  
  286.                 if(Analyse_Horiz(mann->grund,
  287.                     mann->posX>>KOMMA,(mann->posY>>KOMMA)-1)
  288.                     && !mann->verschwindet)
  289.                     {
  290.                     mann->posY -= 1<<KOMMA;
  291.                     Disp_Schritt(mann);
  292.                     break;
  293.                     }
  294.                 if(!Analyse_Horiz
  295.                     (mann->grund, mann->posX>>KOMMA,mann->posY>>KOMMA))
  296.                     {
  297.                     mann->Bewegungsart = fallen;
  298.                     mann->bild = DISP_FALLEND;
  299.                     mann->speedX = Zufall_C_Wert(5L)-2;
  300.                     mann->Warten = 0;
  301.                     }
  302.                 Disp_Schritt(mann);
  303.                 break;
  304.  
  305.             case sitzen:
  306.                 mann->Warten--;
  307.                 if(!mann->Warten)
  308.                     {
  309.                     if(Zufall_Muenzwurf() && !mann->verschwindet)
  310.                         mann->Warten = 1+Zufall_C_Wert((long)SEK0_5);
  311.                     else
  312.                         {
  313.                         mann->Warten = SEK0_5+Zufall_C_Wert((long)SEK2_0);
  314.                         mann->Bewegungsart = stehen;
  315.                         mann->bild = DISP_STEHEND;
  316.                         Disp_Schritt(mann);
  317.                         break;
  318.                         }
  319.                     }
  320.  
  321.                 if(!(Analyse_Horiz(mann->grund,
  322.                     mann->posX>>KOMMA,mann->posY>>KOMMA)) || mann->verschwindet)
  323.                     {
  324.                     mann->Bewegungsart = fallen;
  325.                     mann->bild = DISP_FALLEND;
  326.                     mann->Warten = 0;
  327.                     }
  328.                 Disp_Schritt(mann);
  329.                 break;
  330.  
  331.             case fallen:
  332.                 mann->speedY += GRAVITATION;
  333.                 mann->posY += mann->speedY;
  334.                 mann->posX += mann->speedX;
  335.                 mann->Warten++;
  336.                 if(mann->posY < ((MANN_GROESSE-1)<<KOMMA))
  337.                     {
  338.                     mann->posY = (MANN_GROESSE-1)<<KOMMA;
  339.                     mann->speedY = 0;
  340.                     }
  341.  
  342.                     /* Männchen auf dem Screenrand stehenbleiben lassen */
  343.                 if((mann->posY>>KOMMA) >=
  344.                     mann->grund->normY+mann->grund->sichtbar
  345.                     && mann->grund->begehbar)
  346.                     {
  347.                     mann->posY =
  348.                         ((mann->grund->normY+mann->grund->sichtbar-1)<<KOMMA);
  349.                     mann->speedY = 0;
  350.                     mann->speedX = 0;
  351.                     mann->bild = DISP_STEHEND;
  352.                     mann->Bewegungsart = stehen;
  353.                     if(mann->Warten > SEK2_0)
  354.                         mann->Warten = SEK2_0;
  355.                     mann->Warten += Zufall_C_Wert((long)SEK1_0);
  356.                     }
  357.  
  358.                     /* Männchen nicht seitlich aus dem Bildschirm bewegen */
  359.                 if((mann->speedX<0)?
  360.                     Analyse_Vert(mann->grund,
  361.                         mann->posX>>KOMMA,mann->posY>>KOMMA, 1L):
  362.                     Analyse_Vert(mann->grund,
  363.                         (mann->posX>>KOMMA)+MANN_BREITE,mann->posY>>KOMMA, 1L))
  364.                     {
  365.                     mann->speedX = -mann->speedX;
  366.                     }
  367.  
  368.                     /* Männchen trifft evtl. auf eine waagerechte Linie */
  369.                 if(mann->speedY>=0)
  370.                 if(Analyse_Horiz
  371.                     (mann->grund, mann->posX>>KOMMA,mann->posY>>KOMMA))
  372.                     {
  373.                     mann->speedY = 0;
  374.                     if((mann->Warten<=SEK1_0 || mann->verschwindet) &&
  375.                         (mann->speedX==(1<<KOMMA-1)
  376.                             || mann->speedX==-(1<<KOMMA-1)))
  377.                         {
  378.                         mann->Bewegungsart = gehen;
  379.                         if(mann->speedX<0)
  380.                             mann->bild = DISP_LGEHEND;
  381.                         else
  382.                             mann->bild = DISP_RGEHEND;
  383.                         mann->Warten = 1+Zufall_C_Wert((long)SEK15_0);
  384.                         }
  385.                     else
  386.                         {
  387.                         mann->Bewegungsart = stehen;
  388.                         mann->bild = DISP_STEHEND;
  389.                         mann->speedX = 0;
  390.                         if(mann->Warten > SEK2_0)
  391.                             mann->Warten = SEK2_0;
  392.                         mann->Warten += Zufall_C_Wert((long)SEK1_0);
  393.                         if(mann->verschwindet)
  394.                             mann->Warten = 1;
  395.                         }
  396.                     }
  397.  
  398.                 Disp_Schritt(mann);
  399.                 break;
  400.             }
  401.  
  402.             /* Männchen betrat vielleicht einen anderen Screen */
  403.         if((mann->posY>>KOMMA) < mann->grund->normY ||
  404.             (mann->posY>>KOMMA) >= mann->grund->normY+mann->grund->sichtbar)
  405.             {
  406.             Analyse_Grundlage(mann);
  407.             }
  408.         nextmann:
  409.         mann = (struct Manneintrag *)Liste_C_Sohn(&Mannliste, mann);
  410.         }
  411.     }
  412.  
  413.